JavaScript Modul Repozitoriy Patternlari: Ma'lumotlarga Xavfsiz va Samarali Kirish

            
// user_repository_interface.js

export class IUserRepository {
  async getUserById(id) {
    throw new Error("Method 'getUserById()' must be implemented.");
  }

  async getAllUsers() {
    throw new Error("Method 'getAllUsers()' must be implemented.");
  }

  async createUser(user) {
    throw new Error("Method 'createUser()' must be implemented.");
  }

  async updateUser(id, user) {
    throw new Error("Method 'updateUser()' must be implemented.");
  }

  async deleteUser(id) {
    throw new Error("Method 'deleteUser()' must be implemented.");
  }
}

            

              
                Copy
              
            
          

            
// user_repository_interface.ts

export interface IUserRepository {
  getUserById(id: string): Promise;
  getAllUsers(): Promise;
  createUser(user: User): Promise;
  updateUser(id: string, user: User): Promise;
  deleteUser(id: string): Promise;
}

            

              
                Copy
              
            
          

            
// user_repository.js
import mongoose from 'mongoose';
import { IUserRepository } from './user_repository_interface.js';
const UserSchema = new mongoose.Schema({
  name: String,
  email: String,
});
const UserModel = mongoose.model('User', UserSchema);

export class UserRepository extends IUserRepository {
  constructor(dbUrl) {
        super();
        mongoose.connect(dbUrl).catch(err => console.log(err));
    }
  async getUserById(id) {
    try {
      return await UserModel.findById(id).exec();
    } catch (error) {
      console.error("ID bo'yicha foydalanuvchini olishda xatolik:", error);
      return null; // Yoki xatolikni qayta yuborish, xatoliklarni qayta ishlash strategiyangizga qarab
    }
  }

  async getAllUsers() {
    try {
      return await UserModel.find().exec();
    } catch (error) {
      console.error("Barcha foydalanuvchilarni olishda xatolik:", error);
      return []; // Yoki xatolikni qayta yuborish
    }
  }

  async createUser(user) {
    try {
      const newUser = new UserModel(user);
      return await newUser.save();
    } catch (error) {
      console.error("Foydalanuvchi yaratishda xatolik:", error);
      throw error; // Xatolikni yuqori qatlamda qayta ishlash uchun qayta yuborish
    }
  }

  async updateUser(id, user) {
    try {
      return await UserModel.findByIdAndUpdate(id, user, { new: true }).exec();
    } catch (error) {
      console.error("Foydalanuvchini yangilashda xatolik:", error);
      return null; // Yoki xatolikni qayta yuborish
    }
  }

  async deleteUser(id) {
    try {
      const result = await UserModel.findByIdAndDelete(id).exec();
      return !!result; // Agar foydalanuvchi o'chirilgan bo'lsa, true, aks holda false qaytaradi
    } catch (error) {
      console.error("Foydalanuvchini o'chirishda xatolik:", error);
      return false; // Yoki xatolikni qayta yuborish
    }
  }
}

            

              
                Copy
              
            
          

            
// user_repository.ts
import { Sequelize, DataTypes, Model } from 'sequelize';
import { IUserRepository } from './user_repository_interface.ts';

interface UserAttributes {
  id: string;
  name: string;
  email: string;
}

interface UserCreationAttributes extends Omit {}

class User extends Model implements UserAttributes {
  public id!: string;
  public name!: string;
  public email!: string;

  public readonly createdAt!: Date;
  public readonly updatedAt!: Date;
}

export class UserRepository implements IUserRepository {
  private sequelize: Sequelize;
  private UserModel: typeof User; // Sequelize modelini saqlash

  constructor(sequelize: Sequelize) {
    this.sequelize = sequelize;
    this.UserModel = User.init(
      {
        id: {
          type: DataTypes.UUID,
          defaultValue: DataTypes.UUIDV4,
          primaryKey: true,
        },
        name: {
          type: DataTypes.STRING,
          allowNull: false,
        },
        email: {
          type: DataTypes.STRING,
          allowNull: false,
          unique: true,
        },
      },
      {
        tableName: 'users',
        sequelize: sequelize, // Sequelize nusxasini o'tkazish
      }
    );
  }

  async getUserById(id: string): Promise {
    try {
      return await this.UserModel.findByPk(id);
    } catch (error) {
      console.error("ID bo'yicha foydalanuvchini olishda xatolik:", error);
      return null;
    }
  }

  async getAllUsers(): Promise {
    try {
      return await this.UserModel.findAll();
    } catch (error) {
      console.error("Barcha foydalanuvchilarni olishda xatolik:", error);
      return [];
    }
  }

  async createUser(user: UserCreationAttributes): Promise {
    try {
      return await this.UserModel.create(user);
    } catch (error) {
      console.error("Foydalanuvchi yaratishda xatolik:", error);
      throw error;
    }
  }

  async updateUser(id: string, user: UserCreationAttributes): Promise {
    try {
      const [affectedCount] = await this.UserModel.update(user, { where: { id } });
      if (affectedCount === 0) {
        return null; // Bunday ID'ga ega foydalanuvchi topilmadi
      }
      return await this.UserModel.findByPk(id);
    } catch (error) {
      console.error("Foydalanuvchini yangilashda xatolik:", error);
      return null;
    }
  }

  async deleteUser(id: string): Promise {
    try {
      const deletedCount = await this.UserModel.destroy({ where: { id } });
      return deletedCount > 0; // Agar foydalanuvchi o'chirilgan bo'lsa, true qaytaradi
    } catch (error) {
      console.error("Foydalanuvchini o'chirishda xatolik:", error);
      return false;
    }
  }
}

            

              
                Copy
              
            
          

            
// user_service.js

export class UserService {
  constructor(userRepository) {
    this.userRepository = userRepository;
  }

  async getUserProfile(userId) {
    const user = await this.userRepository.getUserById(userId);
    if (!user) {
      throw new Error("Foydalanuvchi topilmadi");
    }
    return {
      id: user._id,
      name: user.name,
      email: user.email,
    };
  }

  async createUser(userData) {
    // Yaratishdan oldin foydalanuvchi ma'lumotlarini tekshirish
    if (!userData.name || !userData.email) {
      throw new Error("Ism va email talab qilinadi");
    }
    return this.userRepository.createUser(userData);
  }

  // Boshqa servis metodlari...
}

            

              
                Copy
              
            
          

            
// user_service.ts
import { IUserRepository } from './user_repository_interface.ts';
import { User } from './models/user.ts';

export class UserService {
  private userRepository: IUserRepository;

  constructor(userRepository: IUserRepository) {
    this.userRepository = userRepository;
  }

  async getUserProfile(userId: string): Promise {
    const user = await this.userRepository.getUserById(userId);
    if (!user) {
      throw new Error("Foydalanuvchi topilmadi");
    }
    return user;
  }

  async createUser(userData: Omit): Promise {
    // Yaratishdan oldin foydalanuvchi ma'lumotlarini tekshirish
    if (!userData.name || !userData.email) {
      throw new Error("Ism va email talab qilinadi");
    }
    return this.userRepository.createUser(userData);
  }

  // Boshqa servis metodlari...
}

            

              
                Copy
              
            
          

            
// app.js
import { UserService } from './user_service.js';
import { UserRepository } from './user_repository.js';

// MongoDB ulanish satringiz bilan almashtiring
const dbUrl = 'mongodb://localhost:27017/mydatabase';

const userRepository = new UserRepository(dbUrl);
const userService = new UserService(userRepository);

async function main() {
  try {
    const newUser = await userService.createUser({ name: 'John Doe', email: 'john.doe@example.com' });
    console.log('Yaratilgan foydalanuvchi:', newUser);

    const userProfile = await userService.getUserProfile(newUser._id);
    console.log('Foydalanuvchi profili:', userProfile);
  } catch (error) {
    console.error('Xatolik:', error);
  }
}

main();

            

              
                Copy
              
            
          

            
// product_repository_interface.ts
export interface IProductRepository {
  getProductById(id: string): Promise;
  getAllProducts(): Promise;
  getProductsByCategory(category: string): Promise;
  createProduct(product: Product): Promise;
  updateProduct(id: string, product: Product): Promise;
  deleteProduct(id: string): Promise;
}

            

              
                Copy
              
            
          

            
// product_repository.ts
import { IProductRepository } from './product_repository_interface.ts';
import { Product } from './models/product.ts'; // Product modelingiz bor deb faraz qilamiz

export class ProductRepository implements IProductRepository {
  // Ma'lumotlar bazasi ulanishi yoki ORM boshqa joyda ishga tushirilgan deb faraz qilamiz
  private db: any; // 'any' ni haqiqiy ma'lumotlar bazasi turi yoki ORM nusxasi bilan almashtiring

  constructor(db: any) {
    this.db = db;
  }

  async getProductById(id: string): Promise {
    try {
      // 'products' jadvali va mos so'rov metodi deb faraz qilamiz
      const product = await this.db.products.findOne({ where: { id } });
      return product;
    } catch (error) {
      console.error("ID bo'yicha mahsulotni olishda xatolik:", error);
      return null;
    }
  }

  async getAllProducts(): Promise {
    try {
      const products = await this.db.products.findAll();
      return products;
    } catch (error) {
      console.error("Barcha mahsulotlarni olishda xatolik:", error);
      return [];
    }
  }

  async getProductsByCategory(category: string): Promise {
    try {
      const products = await this.db.products.findAll({ where: { category } });
      return products;
    } catch (error) {
      console.error("Kategoriya bo'yicha mahsulotlarni olishda xatolik:", error);
      return [];
    }
  }

  async createProduct(product: Product): Promise {
    try {
      const newProduct = await this.db.products.create(product);
      return newProduct;
    } catch (error) {
      console.error("Mahsulot yaratishda xatolik:", error);
      throw error;
    }
  }

  async updateProduct(id: string, product: Product): Promise {
    try {
      // Mahsulotni yangilang, yangilangan mahsulotni yoki topilmasa null qaytaring
      const [affectedCount] = await this.db.products.update(product, { where: { id } });
      if (affectedCount === 0) {
        return null;
      }
      const updatedProduct = await this.getProductById(id);
      return updatedProduct;
    } catch (error) {
      console.error("Mahsulotni yangilashda xatolik:", error);
      return null;
    }
  }

  async deleteProduct(id: string): Promise {
    try {
      const deletedCount = await this.db.products.destroy({ where: { id } });
      return deletedCount > 0; // Agar o'chirilgan bo'lsa true, topilmasa false
    } catch (error) {
      console.error("Mahsulotni o'chirishda xatolik:", error);
      return false;
    }
  }
}

            

              
                Copy
              
            
          

            
// product_service.ts
import { IProductRepository } from './product_repository_interface.ts';
import { Product } from './models/product.ts';

export class ProductService {
  private productRepository: IProductRepository;

  constructor(productRepository: IProductRepository) {
    this.productRepository = productRepository;
  }

  async getProductDetails(productId: string): Promise {
    // Mahsulot mavjudligini tekshirish kabi biznes mantig'ini qo'shing
    const product = await this.productRepository.getProductById(productId);
    if (!product) {
      return null; // Yoki istisno yuboring
    }
    return product;
  }

  async listProductsByCategory(category: string): Promise {
    // Tavsiya etilgan mahsulotlar bo'yicha filtrlash kabi biznes mantig'ini qo'shing
    return this.productRepository.getProductsByCategory(category);
  }

  async createNewProduct(productData: Omit): Promise {
    // Tekshirish, tozalash va h.k. amallarni bajaring
    return this.productRepository.createProduct(productData);
  }

  // Mahsulotlarni yangilash, o'chirish va hokazolar uchun boshqa servis metodlarini qo'shing
}

            

              
                Copy